#include <vcl.h>
#pragma hdrstop

#include <Eic.h>
#include "MTAG_Outils.h"
#include "uParamCourrierEtCarnAdr.h" //Pour GetRepsCourrier
#include "CCourrierBR.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------
// ValidCtrCheck est utilisé est utilisé pour être sûr que les composants créés n'ont
// aucune fonction virtuelle pure.
//

#define MODULE_TAG MTAG_CCOURRIERBR

static inline void ValidCtrCheck(CCourrierBR *)
{
  new CCourrierBR(NULL);
}
//---------------------------------------------------------------------------
__fastcall CCourrierBR::CCourrierBR(TComponent* Owner)
  : TComponent(Owner)
{
try
   {
   hCourrier = NULL;
   _SauverTout = NULL;
   _SauverModeles = NULL;
   _Decompresser = NULL;
   _RestaurerModeles = NULL;
   _RestaurerAPartirCoordDoss = NULL;
   _Effacer = NULL;
   _RafraichirRepDatas = NULL;
   _SauvegarderModReq = NULL;
   _RestaurerModReq = NULL;

   m_ListeModeles = NULL;
   
   FOnInsertFloppy = NULL;
   FOnIncrementation = NULL;
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(0), e);
   }
}
//---------------------------------------------------------------------------
__fastcall CCourrierBR::~CCourrierBR()
{
  if (_Decompresser) //SI la décompression a été lancée, on doit procéder à la destruction
     Effacer();


  FreeLibrary(hCourrier);
  hCourrier = NULL;
  ViderListeModeles();
}

/*******************************************************************************
bool __fastcall CCourrierBR::SauverTout()

Fonction : Sauvegarde le carnet d'adresses, les tables du courrier et les
           courriers utilisés, pour le logiciel paramétré.
           Si Logiciel est vide, les courriers de tous les logiciels seront sauvegardés.

Valeur retournée :
*******************************************************************************/
bool __fastcall CCourrierBR::SauverTout()
{
  AnsiString aFichierCible, aRepDll;
  bool bSauver = false;
  try
  {
    if (!hCourrier)
    {
       GetRepsCourrier(&aRepDll, NULL, NULL);
       aRepDll +="EicEdito.dll";
       hCourrier = LoadLibrary (aRepDll.c_str());
       if (!hCourrier)
          throw EAbort("Impossible de charger "+ aRepDll);
    }
    if (!_SauverTout)
    {
      _SauverTout = (FctSauverTout) GetProcAddress(hCourrier, "_SauverTout");
      if (!_SauverTout)
        throw EAbort("Impossible de charger la fonction _SauverTout");
    }
    aFichierCible = m_aRepTravail + m_aNomFichier;
    bSauver = _SauverTout(m_aNomLogiciel, aFichierCible, m_aRepTmp, FOnInsertFloppy, FOnIncrementation);
  }
  catch(Exception &e)
  {
    EICDisplayException(TAG(10), e);
  }
  return bSauver;
}

/*******************************************************************************
void __fastcall CCourrierBR::AddModele(const AnsiString &Logiciel,
                                       const AnsiString &Categorie,
                                       const AnsiString &Libelle)

Fonction : Ajoute le modèle spécifié à la liste des modèles qui sera sauvegardé
           lors de l'appel à la fonction SauverModeles

Paramètres d'entrée :

*******************************************************************************/
void __fastcall CCourrierBR::AddModele(const AnsiString &Logiciel,
                                       const AnsiString &Categorie,
                                       const AnsiString &Libelle)
{
TRefModele *sRefModele = NULL;
try
   {
   if (!m_ListeModeles)
      m_ListeModeles = new TList();
   sRefModele = new TRefModele();
   sRefModele->aLogiciel = Logiciel;
   sRefModele->aCategorie = Categorie;
   sRefModele->aLibelle = Libelle;
   m_ListeModeles->Add(sRefModele);
   }
catch (Exception &e)
   {
   delete sRefModele;
   EICDisplayException(TAGL,e);
   }
}
/*******************************************************************************
bool __fastcall CCourrierBR::SauverModeles()

Fonction : Sauvegarde les modèles qui ont été recensé suite aux appels de la fonction AddModele

Valeur retournée :
*******************************************************************************/
bool __fastcall CCourrierBR::SauverModeles()
{
AnsiString aFichierCible, aRepDll;
bool bSauver = false;
try
   {
   if (!m_ListeModeles)
      return false;

   if (!hCourrier)
      {
      GetRepsCourrier(&aRepDll, NULL, NULL);
      aRepDll +="EicEdito.dll";
      hCourrier = LoadLibrary (aRepDll.c_str());
      if (!hCourrier)
         throw EAbort("Impossible de charger "+ aRepDll);
      }
   if (!_SauverModeles)
      {
      _SauverModeles = (FctSauverModeles) GetProcAddress(hCourrier, "_SauverModeles");
      if (!_SauverModeles)
         throw EAbort("Impossible de charger la fonction _SauverModeles");
      }
   aFichierCible = m_aRepTravail + m_aNomFichier;
   bSauver = _SauverModeles(m_ListeModeles, aFichierCible, m_aRepTmp, FOnInsertFloppy, FOnIncrementation);

   ViderListeModeles(); //Sauvegarde réussie => Réinitialisation de la liste pour une éventuelle future sauvegarde
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(15), e);
   }
return bSauver;
}
/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
bool __fastcall CCourrierBR::Decompresser()
{
  AnsiString aFichierSource, aRepDll;
  bool bDecompresser = false;
  try
  {
    if (!hCourrier)
       {
       GetRepsCourrier(&aRepDll, NULL, NULL);
       aRepDll +="EicEdito.dll";
       hCourrier = LoadLibrary (aRepDll.c_str());
       if (!hCourrier)
          throw EAbort("Impossible de charger "+ aRepDll);
       }
    if (!_Decompresser)
    {
      _Decompresser = (FctDecompresser) GetProcAddress(hCourrier, "_Decompresser");
      if (!_Decompresser)
        throw EAbort("Impossible de charger la fonction _Decompresser");
    }

    aFichierSource = m_aRepTravail + m_aNomFichier;
    bDecompresser = _Decompresser(aFichierSource, m_aRepTmp, FOnInsertFloppy, FOnIncrementation);
  }
  catch(Exception &e)
  {
    EICDisplayException(TAG(20), e);
  }
  return bDecompresser;
}
/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
bool __fastcall CCourrierBR::RestaurerModeles(enum eTypeRestauration ModeRestauration)
{
bool bRestaurer = false;
try
   {
   Decompresser();
   if (!_RestaurerModeles)
      {
      _RestaurerModeles = (FctRestaurerModeles) GetProcAddress(hCourrier, "_RestaurerModeles");
      if (!_RestaurerModeles)
         throw EAbort("Impossible de charger la fonction _RestaurerModeles");
      }
   bRestaurer = _RestaurerModeles(ModeRestauration);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(30), e);
   }
return bRestaurer;
}

/*******************************************************************************
bool __fastcall CCourrierBR::Restaurer(unsigned long *NumeroCoordonnee,
                                       eTypeRestauration ModeRestauration,
                                       const AnsiString &aRepSecondaire)

Fonction : Restauration des courriers et fiches du carnet d'adresses associés à une coordonnée

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
bool __fastcall CCourrierBR::Restaurer(unsigned long *NumeroCoordonnee,
                                       eTypeRestauration ModeRestauration,
                                       const AnsiString &aRepSecondaire)
{
  bool bRestaurer = false;
  try
  {
  //La fonction Decompresser doit obligatoirement avoir été appelé avant
  //hCourrier doit donc être initialisé.
  ASSERT(hCourrier);

    if (!_RestaurerAPartirCoordDoss)
    {
      _RestaurerAPartirCoordDoss = (FctRestaurerAPartirCoordDoss) GetProcAddress(hCourrier, "_RestaurerAPartirCoordDoss");
      if (!_RestaurerAPartirCoordDoss)
        throw EAbort("Impossible de charger la fonction _RestaurerAPartirCoordDoss");
    }
    bRestaurer = _RestaurerAPartirCoordDoss(NumeroCoordonnee,
                                            ModeRestauration,
                                            aRepSecondaire);
  }
  catch(Exception &e)
  {
    EICDisplayException(TAG(35), e);
  }
  return bRestaurer;
}
//---------------------------------------------------------------------------
bool __fastcall CCourrierBR::Effacer()
{
  bool bEffacer = false;
  try
  {
  //La fonction Decompresser doit obligatoirement avoir été appelé avant
  //hCourrier doit donc être initialisé.
  ASSERT(hCourrier);

    if (!_Effacer)
    {
      _Effacer = (FctEffacer) GetProcAddress(hCourrier, "_Effacer");
      if (!_Effacer)
        throw EAbort("Impossible de charger la fonction _Effacer");
    }

  bEffacer = _Effacer();
  }
  catch(Exception &e)
  {
    EICDisplayException(TAG(40), e);
  }
return bEffacer;
}

/*******************************************************************************

Fonction :

P.E :

P.E modifiés :

P.S :
*******************************************************************************/
void __fastcall  CCourrierBR::SetRepTemp (const AnsiString aRep)
{
try
   {
   m_aRepTmp = aRep;
   if (m_aRepTmp.LastDelimiter("\\") != m_aRepTmp.Length())
      m_aRepTmp += "\\";
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(60), e);
   }
}

/*******************************************************************************

Fonction :

P.E :

P.E modifiés :

P.S :
*******************************************************************************/
void __fastcall CCourrierBR::SetRepTrav (const AnsiString aRep)
{
try
   {
   m_aRepTravail = aRep;
   if (m_aRepTravail.LastDelimiter("\\") != m_aRepTravail.Length())
      m_aRepTravail += "\\";
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(70), e);
   }
}
/*******************************************************************************

Fonction :

P.E :

P.E modifiés :

P.S :
*******************************************************************************/
bool __fastcall CCourrierBR::RafraichirRepDatas()
{
bool bRetour = false;
try
  {
    if (!hCourrier)
       {
       AnsiString aRepDll;
       GetRepsCourrier(&aRepDll, NULL, NULL);
       aRepDll +="EicEdito.dll";
       hCourrier = LoadLibrary (aRepDll.c_str());
       if (!hCourrier)
          throw EAbort("Impossible de charger "+ aRepDll);
       }
    if (!_RafraichirRepDatas)
      {
      _RafraichirRepDatas = (FctRafraichirRepDatasCourrier) GetProcAddress(hCourrier, "_RafraichirRepDatasCourrier");
      if (!_RafraichirRepDatas)
        throw EAbort("Impossible de charger la fonction _RafraichirRepDatasCourrier");
      }

    bRetour = _RafraichirRepDatas();
  }
  catch(Exception &e)
  {
    EICDisplayException(TAG(80), e);
  }
return bRetour;
}


/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall CCourrierBR::ViderListeModeles()
{
try
   {
   if (m_ListeModeles)
      {
      for (int i = 0;i < m_ListeModeles->Count;i++)
         delete (TRefModele *)m_ListeModeles->Items[i];
      m_ListeModeles->Clear();

      delete m_ListeModeles;    m_ListeModeles = NULL;
      }
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(90), e);
   }
}

/*******************************************************************************
bool __fastcall CCourrierBR::SauvegarderModReq(TList *lstModelesASauvegarder)

Fonction : Sauvegarde les courriers spécifiés dans la table dont le chemin est passé en paramètre

Paramètres d'entrée : aRepTableModReq : Chemin ou se trouve le nom des courriers a sauvegarder
                               Si NULL, on ne sauvegarde rien
Valeur retournée : sauvegarde réussit ou non
*******************************************************************************/
bool __fastcall CCourrierBR::SauvegarderModReq(const AnsiString &aRepTableModReq)
{
  AnsiString aFichierCible, aRepDll;
  bool bSauver = false;
  try
    {
    if(aRepTableModReq.IsEmpty())return false;
    if (!hCourrier)
      {
      GetRepsCourrier(&aRepDll, NULL, NULL);
      aRepDll +="EicEdito.dll";
      hCourrier = LoadLibrary (aRepDll.c_str());
      if (!hCourrier)
         throw EAbort("Impossible de charger "+ aRepDll);
      }
    if (!_SauvegarderModReq)
      {
      _SauvegarderModReq = (FctSauvegarderModReq) GetProcAddress(hCourrier, "_SauvegarderModReq");
      if (!_SauvegarderModReq)
         throw EAbort("Impossible de charger la fonction _SauvegarderModReq");
      }
    aFichierCible = m_aRepTravail + m_aNomFichier;
    bSauver = _SauvegarderModReq(aRepTableModReq, aFichierCible, m_aRepTmp, FOnInsertFloppy, FOnIncrementation);
    }
  catch(Exception &e)
    {
    EICDisplayException(TAG(100), e);
    }
  return bSauver;
}

/*******************************************************************************
bool __fastcall CCourrierBR::RestaurerModReq(enum eTypeRestauration ModeRestauration,
                                             const AnsiString &aRepSecondaire)

Fonction : Restaure tous les modèles utilisés (Source : fichier .br spécifié par les propriétés RepertoireTravail et NomFichier)


Paramètres d'entrée : ModeRestauration : mode de restauration
                      aRepSecondaire : repertoire ou pourrai se trouver les courriers secondaires.

Valeur retournée : restauration réussit ou non
*******************************************************************************/
bool __fastcall CCourrierBR::RestaurerModReq(enum eTypeRestauration ModeRestauration,
                                             const AnsiString &aRepSecondaire)
{
  bool bRestaurer = false;
  AnsiString aFichierSource, aRepDll;
  try
    {
    if (!hCourrier)
      {
      GetRepsCourrier(&aRepDll, NULL, NULL);
      aRepDll +="EicEdito.dll";
      hCourrier = LoadLibrary (aRepDll.c_str());
      if (!hCourrier)
         throw EAbort("Impossible de charger "+ aRepDll);
      }
    if (!_RestaurerModReq)
      {
      _RestaurerModReq = (FctRestaurerModReq) GetProcAddress(hCourrier, "_RestaurerModReq");
      if (!_RestaurerModReq)
        throw EAbort("Impossible de charger la fonction _RestaurerModReq");
      }
    aFichierSource = m_aRepTravail + m_aNomFichier;
    bRestaurer = _RestaurerModReq(aFichierSource, m_aRepTmp, ModeRestauration, aRepSecondaire);
    }
  catch(Exception &e)
    {
    EICDisplayException(TAG(110), e);
    }
  return bRestaurer;
} 

//---------------------------------------------------------------------------
namespace Ccourrierbr
{
  void __fastcall PACKAGE Register()
  {
     TComponentClass classes[1] = {__classid(CCourrierBR)};
     RegisterComponents("EIC Outils", classes, 0);
  }
}
